home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 3: Developer Tools / Linux Cubed Series 3 - Developer Tools.iso / devel / db / esm-3.1 / esm-3 / usr / local / sm / src / serverlib / redo / redoBtree.C < prev    next >
Encoding:
C/C++ Source or Header  |  1996-05-05  |  8.5 KB  |  309 lines
  1. /*
  2.  *   $RCSfile: redoBtree.C,v $  
  3.  *   $Revision: 1.1.1.1 $  
  4.  *   $Date: 1996/05/04 21:55:58 $      
  5.  */ 
  6. /**********************************************************************
  7. * EXODUS Database Toolkit Software
  8. * Copyright (c) 1991 Computer Sciences Department, University of
  9. *                    Wisconsin -- Madison
  10. * All Rights Reserved.
  11. *
  12. * Permission to use, copy, modify and distribute this software and its
  13. * documentation is hereby granted, provided that both the copyright
  14. * notice and this permission notice appear in all copies of the
  15. * software, derivative works or modified versions, and any portions
  16. * thereof, and that both notices appear in supporting documentation.
  17. *
  18. * THE COMPUTER SCIENCES DEPARTMENT OF THE UNIVERSITY OF WISCONSIN --
  19. * MADISON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS" CONDITION.  
  20. * THE DEPARTMENT DISCLAIMS ANY LIABILITY OF ANY KIND FOR ANY DAMAGES
  21. * WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
  22. *
  23. * The EXODUS Project Group requests users of this software to return 
  24. * any improvements or extensions that they make to:
  25. *
  26. *   EXODUS Project Group 
  27. *     c/o David J. DeWitt and Michael J. Carey
  28. *   Computer Sciences Department
  29. *   University of Wisconsin -- Madison
  30. *   Madison, WI 53706
  31. *
  32. *     or exodus@cs.wisc.edu
  33. *
  34. * In addition, the EXODUS Project Group requests that users grant the 
  35. * Computer Sciences Department rights to redistribute these changes.
  36. **********************************************************************/
  37. #include "BTREEPAGE.h"
  38. #include "BT_Log.h"
  39. #include "bf_macro.h"
  40. #include "redo_intfuncs.h"
  41.  
  42.  
  43. #ifdef DEBUG
  44. int redoBtreeTrace = FALSE;
  45. #undef BT_TRACE
  46. #define BT_TRACE(x)  { if (redoBtreeTrace)  printf x; }
  47. extern char* BT_PrintKey(SMDATATYPE type, void* key, int len);
  48.  
  49. #else  /* def DEBUG */
  50. #define BT_TRACE(x)  
  51. #endif  /* def DEBUG */
  52.  
  53.  
  54. // call the friend separately to avoid g++ bug
  55. void redoBtree(LOGRECORDHDR* recHdr)
  56. {
  57.     redoBtree_fr(recHdr);
  58. }
  59.  
  60.  
  61. void redoBtree_fr(LOGRECORDHDR* recHdr)
  62. {
  63.  
  64.     TRPRINT(TR_IO|TR_LOG, TR_LEVEL_1, ("lsn:%d", recHdr->recordLSN.offset));
  65.  
  66.     PID* pid = & recHdr->actionPid;
  67.     TRPRINT(TR_IO|TR_LOG, TR_LEVEL_2, ("pid:%d", pid->page));
  68.  
  69.     //
  70.     //    Check to see if the operation needs to be redone
  71.     //
  72.     GROUPLINK* gLink;
  73.     if (!redoCheckPage(recHdr, &gLink, PAGE_INDEX))  {
  74.         //
  75.         //    Don't need to redo
  76.         //
  77.         TRPRINT(TR_RECOVER, TR_LEVEL_2, ("dirty page not present"));
  78.         return;
  79.         }
  80.     CHECK_GROUPLINK_MAGIC(gLink);
  81.  
  82.     BTREEPAGE* bp = (BTREEPAGE*) gLink->bufFrame;
  83.  
  84.     //
  85.     //    redo 
  86.     //
  87.     void* vptr = GET_LOG_IMAGE(recHdr, 0);
  88.     BT_TRACE(("R(%d,%d): ", recHdr->recordLSN.offset, pid->page));
  89.     
  90.     switch (recHdr->action)  {
  91.         BT_Tuple* tp;
  92.         BT_Tuple tmp;
  93.         int keyExists;
  94.         TWO slot;
  95.         int i;
  96.         
  97.  
  98.         case LOG_ACTION_BTREE_PAGE_INIT:
  99.                 {
  100.                 LogBtreePageInitData* rp = (LogBtreePageInitData*) vptr;
  101.                 BT_TRACE(("init\n"));
  102.                 bp->Init(*pid, rp->newLevel, rp->keyType);
  103.                 }
  104.                 break;
  105.                 
  106.         case LOG_ACTION_BTREE_MODIFY_LINK:
  107.                 {
  108.                 LogBtreeModifyLinkData* rp = (LogBtreeModifyLinkData*) vptr;
  109.                 ASSERT3(bp->NextPage() == rp->oldNext);
  110.                 ASSERT3(bp->PrevPage() == rp->oldPrev);
  111.                 BT_TRACE(("modify link\n"));
  112.                 bp->btCtrl.next = rp->newNext;
  113.                 bp->btCtrl.prev = rp->newPrev;
  114.                 }
  115.                 break;
  116.                 
  117.         case LOG_ACTION_BTREE_MODIFY_VECTOR0:
  118.                 {
  119.                 LogBtreeModifyVector0Data* rp = 
  120.                                         (LogBtreeModifyVector0Data*) vptr;
  121.                 ASSERT3(bp->FirstVector() == rp->oldPid0);
  122.                 BT_TRACE(("modify vec0\n"));
  123.                 bp->SetFirstVector(rp->newPid0);
  124.                 }
  125.                 break;
  126.                 
  127.         case LOG_ACTION_BTREE_MODIFY_LEVEL:
  128.                 {
  129.                 LogBtreeModifyLevelData* rp = (LogBtreeModifyLevelData*) vptr;
  130.                 ASSERT3(bp->Level() == rp->oldLevel);
  131.                 BT_TRACE(("set level\n"));
  132.                 bp->SetLevel(rp->newLevel);
  133.                 }
  134.                 break;
  135.                 
  136.         case LOG_ACTION_BTREE_PHYSIC_INSERT:
  137.                 {
  138.                 LogBtreePhysicInsertData* rp =
  139.                                         (LogBtreePhysicInsertData*) vptr;
  140.                 ASSERT3(rp->startSlot >= 0 && rp->numSlots > 0);
  141.                 char* buff = rp->data;
  142.                 BT_TRACE(("physic insert"));
  143.                 for (i = rp->startSlot; i < rp->startSlot+rp->numSlots; i++)  {
  144.                     tp = (BT_Tuple*) buff;
  145.                     BT_TRACE((" %d", * (int*) tp->KeyValue()));
  146.                     bp->InsertTuple(*tp, i);
  147.                     buff += tp->Size();
  148.                     }
  149.                 BT_TRACE(("\n"));
  150.     /*    
  151.                 BT_PrintFunc = IntPrint;
  152.                 bp->Print(UserBufGroup);
  153.     */
  154.                 }
  155.                 break;
  156.                 
  157.                 
  158.         case LOG_ACTION_BTREE_PHYSIC_DELETE:
  159.                 {
  160.                 LogBtreePhysicDeleteData* rp =
  161.                                         (LogBtreePhysicDeleteData*) vptr;
  162.                 ASSERT3(rp->startSlot >= 0 && rp->numSlots > 0);
  163.                 BT_TRACE(("physic delete"));
  164.                 for (i = rp->startSlot + rp->numSlots - 1; 
  165.                                                 i >= rp->startSlot; i--)  {
  166.                     BT_TRACE((" %d", *(int*) bp->Tuple(i).KeyValue()));
  167.                     bp->RemoveTuple(i);
  168.                     }
  169.                 BT_TRACE(("\n"));
  170.     /*    
  171.                 BT_PrintFunc = IntPrint;
  172.                 bp->Print(UserBufGroup);
  173.     */
  174.                 }
  175.                 break;
  176.                 
  177.         case LOG_ACTION_BTREE_LOGIC_INSERT:
  178.                 {
  179.                 LogBtreeLogicInsertData* rp =
  180.                                         (LogBtreeLogicInsertData*) vptr;
  181.                                         
  182.                 keyExists = bp->Search(rp->keyLen, rp->Key(), 
  183.                                         SMCOMPFUNC[rp->keyType],slot);
  184.                 ASSERT3(bp->IsLeaf());
  185.                 BT_TRACE(("logic insert %s\n", BT_PrintKey(rp->keyType, 
  186.                                                     rp->Key(), rp->keyLen)));
  187.                 ASSERT3(rp->elSize > 0 && rp->elSize <= SM_MAXELEMLEN);
  188.                 if (keyExists) {
  189.                     ASSERT1(!rp->unique);
  190.                     if (bp->AddElem(slot, rp->El())) {
  191.                         SM_ERROR(TYPE_FATAL, Active->errno);
  192.                         }
  193.                     }
  194.                 else {
  195.                     tmp.Create(rp->keyLen, rp->Key(), rp->El(), rp->elSize);
  196.                     bp->InsertTuple(tmp, slot);
  197.                     }
  198.                 }
  199.                 break;
  200.                     
  201.                 
  202.         case LOG_ACTION_BTREE_LOGIC_DELETE:
  203.                 {
  204.                 LogBtreeLogicDeleteData* rp =
  205.                                         (LogBtreeLogicDeleteData*) vptr;
  206.                                         
  207.                 keyExists = bp->Search(rp->keyLen, rp->Key(), 
  208.                                         SMCOMPFUNC[rp->keyType],slot);
  209.                 ASSERT3(bp->IsLeaf());
  210.                 BT_TRACE(("logic delete %s\n", BT_PrintKey(rp->keyType, 
  211.                                                     rp->Key(), rp->keyLen)));
  212.                 ASSERT1(keyExists);
  213.                 ASSERT3(bp->Tuple(slot).KeyLen() == rp->keyLen);
  214.                 ASSERT3((SMCOMPFUNC[rp->keyType])(rp->keyLen, rp->Key(), 
  215.                             rp->keyLen, bp->Tuple(slot).KeyValue()) == 0);
  216.                 ASSERT3(rp->elSize > 0 && rp->elSize <= SM_MAXELEMLEN);
  217.                 if (bp->RemoveElem(slot, rp->El()))  {
  218.                     SM_ERROR(TYPE_FATAL, Active->errno);
  219.                     }
  220.                 if (bp->Tuple(slot).ElCnt() == 0)  {
  221.                     bp->RemoveTuple(slot);
  222.                     }
  223.                 }
  224.                 break;
  225.                 
  226.         case LOG_ACTION_BTREE_LOGIC_INCR_OIDCNT:
  227.                 {
  228.                 LogBtreeLogicIncrElCntData* rp =
  229.                                         (LogBtreeLogicIncrElCntData*) vptr;
  230.                 
  231.                 keyExists = bp->Search(rp->keyLen, rp->key,
  232.                                                 SMCOMPFUNC[rp->keyType],slot);
  233.                 ASSERT1(keyExists);
  234.                 ASSERT3(bp->Tuple(slot).KeyLen() == rp->keyLen);
  235.                 ASSERT3((SMCOMPFUNC[rp->keyType])(rp->keyLen, rp->key, rp->
  236.                                     keyLen, bp->Tuple(slot).KeyValue()) == 0);
  237.                 BT_TRACE(("++oidcnt\n"));
  238.                 bp->Tuple(slot).IncrElCnt();
  239.                 }
  240.                 break;
  241.                 
  242.         case LOG_ACTION_BTREE_LOGIC_DECR_OIDCNT:
  243.                 {
  244.                 LogBtreeLogicDecrElCntData* rp =
  245.                                         (LogBtreeLogicDecrElCntData*) vptr;
  246.                 
  247.                 keyExists = bp->Search(rp->keyLen, rp->key,
  248.                                                 SMCOMPFUNC[rp->keyType],slot);
  249.                 ASSERT1(keyExists);
  250.                 ASSERT3(bp->Tuple(slot).KeyLen() == rp->keyLen);
  251.                 ASSERT3((SMCOMPFUNC[rp->keyType])(rp->keyLen, rp->key, rp->
  252.                                     keyLen, bp->Tuple(slot).KeyValue()) == 0);
  253.  
  254.                 BT_TRACE(("--oidcnt\n"));
  255.                 bp->Tuple(slot).DecrElCnt();
  256.                 }
  257.                 break;
  258.  
  259.         case LOG_ACTION_BTREE_LOGIC_SET_OVERFLOW:
  260.                 {
  261.                 LogBtreeLogicSetOverflowData* rp =
  262.                                         (LogBtreeLogicSetOverflowData*) vptr;
  263.                                         
  264.                 keyExists = bp->Search(rp->keyLen, rp->KeyValue(), 
  265.                                                 SMCOMPFUNC[rp->keyType], slot);
  266.                 ASSERT1(keyExists);
  267.                 tp = & bp->Tuple(slot);
  268.                 ASSERT3(tp->KeyLen() == rp->keyLen);
  269.                 ASSERT3(tp->ElCnt() == rp->numEl);
  270.                 ASSERT3((SMCOMPFUNC[rp->keyType])(rp->keyLen, rp->KeyValue(), 
  271.                                         rp->keyLen, tp->KeyValue()) == 0);
  272.                 BT_TRACE(("set overflow\n"));
  273.                 bp->SetOverflow(slot, rp->ovPid);
  274.                 }
  275.                 break;
  276.                 
  277.                 
  278.         case LOG_ACTION_BTREE_LOGIC_RESET_OVERFLOW:
  279.                 {
  280.                 LogBtreeLogicSetOverflowData* rp =
  281.                                         (LogBtreeLogicSetOverflowData*) vptr;
  282.                                         
  283.                 keyExists = bp->Search(rp->keyLen, rp->KeyValue(), 
  284.                                                 SMCOMPFUNC[rp->keyType], slot);
  285.                 ASSERT1(keyExists);
  286.                 tp = & bp->Tuple(slot);
  287.                 ASSERT3(tp->KeyLen() == rp->keyLen);
  288.                 ASSERT3(tp->ElCnt() == rp->numEl);
  289.                 ASSERT3((SMCOMPFUNC[rp->keyType])(rp->keyLen, rp->KeyValue(), 
  290.                                         rp->keyLen, tp->KeyValue()) == 0);
  291.                 
  292.                 BT_TRACE(("reset overflow\n"));
  293.                 /* if condition ?? */
  294.                 bp->SetUnderflow(slot, rp->numEl, rp->ElList());
  295.                 }
  296.                 break;
  297.  
  298.         default:                
  299.                 SM_ERROR(TYPE_FATAL, esmINTERNAL);
  300.         }
  301.     ASSERT3(bp->CheckContent());
  302.  
  303.     bp->lrc() = recHdr->actionLRC;
  304.  
  305.     signalSemaphore(&gLink->pageHash->semaphore);
  306.  
  307.     bf_UnfixPage(gLink, BF_DEFAULT, TRUE);
  308. }
  309.